// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.tmp.tiktok.order;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.TmpTiktokOrder;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(TmpTiktokOrder.class)
@Setter
@Getter
public class TmpTiktokOrderSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "TmpTiktokOrder".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 订单号(模糊搜索)
   */
  private String orderId;

  /**
   * 订单号 比较(eq)
   */
  private String orderIdEq;
  /**
   * 订单号 比较(neq)
   */
  private String orderIdNeq;
  /**
   * 订单号 比较(gt)
   */
  private String orderIdGt;
  /**
   * 订单号 比较(gte)
   */
  private String orderIdGte;
  /**
   * 订单号 比较(lt)
   */
  private String orderIdLt;
  /**
   * 订单号 比较(lte)
   */
  private String orderIdLte;
  /**
   * 订单号 比较(contains)
   */
  private String orderIdContains;
  /**
   * 订单号 比较(notcontains)
   */
  private String orderIdNotcontains;
  /**
   * 订单号 比较(startswith)
   */
  private String orderIdStartswith;
  /**
   * 订单号 比较(endswith)
   */
  private String orderIdEndswith;
  /**
   * 订单号 比较(isnull)
   */
  private Boolean orderIdIsnull;
  /**
   * 订单号 比较(isnotnull)
   */
  private Boolean orderIdIsnotnull;

  /**
   * 订单号(精确搜索)
   */
  private List<String> orderIdInList;

  /**
   * 订单状态(模糊搜索)
   */
  private String status;

  /**
   * 订单状态 比较(eq)
   */
  private String statusEq;
  /**
   * 订单状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 订单状态 比较(gt)
   */
  private String statusGt;
  /**
   * 订单状态 比较(gte)
   */
  private String statusGte;
  /**
   * 订单状态 比较(lt)
   */
  private String statusLt;
  /**
   * 订单状态 比较(lte)
   */
  private String statusLte;
  /**
   * 订单状态 比较(contains)
   */
  private String statusContains;
  /**
   * 订单状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 订单状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 订单状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 订单状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 订单状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 订单状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 物流商名称(模糊搜索)
   */
  private String shippingProvider;

  /**
   * 物流商名称 比较(eq)
   */
  private String shippingProviderEq;
  /**
   * 物流商名称 比较(neq)
   */
  private String shippingProviderNeq;
  /**
   * 物流商名称 比较(gt)
   */
  private String shippingProviderGt;
  /**
   * 物流商名称 比较(gte)
   */
  private String shippingProviderGte;
  /**
   * 物流商名称 比较(lt)
   */
  private String shippingProviderLt;
  /**
   * 物流商名称 比较(lte)
   */
  private String shippingProviderLte;
  /**
   * 物流商名称 比较(contains)
   */
  private String shippingProviderContains;
  /**
   * 物流商名称 比较(notcontains)
   */
  private String shippingProviderNotcontains;
  /**
   * 物流商名称 比较(startswith)
   */
  private String shippingProviderStartswith;
  /**
   * 物流商名称 比较(endswith)
   */
  private String shippingProviderEndswith;
  /**
   * 物流商名称 比较(isnull)
   */
  private Boolean shippingProviderIsnull;
  /**
   * 物流商名称 比较(isnotnull)
   */
  private Boolean shippingProviderIsnotnull;

  /**
   * 物流商名称(精确搜索)
   */
  private List<String> shippingProviderInList;

  /**
   * 物流商ID(模糊搜索)
   */
  private String shippingProviderId;

  /**
   * 物流商ID 比较(eq)
   */
  private String shippingProviderIdEq;
  /**
   * 物流商ID 比较(neq)
   */
  private String shippingProviderIdNeq;
  /**
   * 物流商ID 比较(gt)
   */
  private String shippingProviderIdGt;
  /**
   * 物流商ID 比较(gte)
   */
  private String shippingProviderIdGte;
  /**
   * 物流商ID 比较(lt)
   */
  private String shippingProviderIdLt;
  /**
   * 物流商ID 比较(lte)
   */
  private String shippingProviderIdLte;
  /**
   * 物流商ID 比较(contains)
   */
  private String shippingProviderIdContains;
  /**
   * 物流商ID 比较(notcontains)
   */
  private String shippingProviderIdNotcontains;
  /**
   * 物流商ID 比较(startswith)
   */
  private String shippingProviderIdStartswith;
  /**
   * 物流商ID 比较(endswith)
   */
  private String shippingProviderIdEndswith;
  /**
   * 物流商ID 比较(isnull)
   */
  private Boolean shippingProviderIdIsnull;
  /**
   * 物流商ID 比较(isnotnull)
   */
  private Boolean shippingProviderIdIsnotnull;

  /**
   * 物流商ID(精确搜索)
   */
  private List<String> shippingProviderIdInList;

  /**
   * 最早支付时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date paidTimeStart;

  /**
   * 最晚支付时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date paidTimeEnd;

  /**
   * 支付时间 比较(eq)
   */
  private Date paidTimeEq;
  /**
   * 支付时间 比较(neq)
   */
  private Date paidTimeNeq;
  /**
   * 支付时间 比较(gt)
   */
  private Date paidTimeGt;
  /**
   * 支付时间 比较(gte)
   */
  private Date paidTimeGte;
  /**
   * 支付时间 比较(lt)
   */
  private Date paidTimeLt;
  /**
   * 支付时间 比较(lte)
   */
  private Date paidTimeLte;
  /**
   * 支付时间 比较(contains)
   */
  private Date paidTimeContains;
  /**
   * 支付时间 比较(notcontains)
   */
  private Date paidTimeNotcontains;
  /**
   * 支付时间 比较(startswith)
   */
  private Date paidTimeStartswith;
  /**
   * 支付时间 比较(endswith)
   */
  private Date paidTimeEndswith;
  /**
   * 支付时间 比较(isnull)
   */
  private Boolean paidTimeIsnull;
  /**
   * 支付时间 比较(isnotnull)
   */
  private Boolean paidTimeIsnotnull;

  /**
   * 卖家留言(模糊搜索)
   */
  private String buyerMessage;

  /**
   * 卖家留言 比较(eq)
   */
  private String buyerMessageEq;
  /**
   * 卖家留言 比较(neq)
   */
  private String buyerMessageNeq;
  /**
   * 卖家留言 比较(gt)
   */
  private String buyerMessageGt;
  /**
   * 卖家留言 比较(gte)
   */
  private String buyerMessageGte;
  /**
   * 卖家留言 比较(lt)
   */
  private String buyerMessageLt;
  /**
   * 卖家留言 比较(lte)
   */
  private String buyerMessageLte;
  /**
   * 卖家留言 比较(contains)
   */
  private String buyerMessageContains;
  /**
   * 卖家留言 比较(notcontains)
   */
  private String buyerMessageNotcontains;
  /**
   * 卖家留言 比较(startswith)
   */
  private String buyerMessageStartswith;
  /**
   * 卖家留言 比较(endswith)
   */
  private String buyerMessageEndswith;
  /**
   * 卖家留言 比较(isnull)
   */
  private Boolean buyerMessageIsnull;
  /**
   * 卖家留言 比较(isnotnull)
   */
  private Boolean buyerMessageIsnotnull;

  /**
   * 卖家留言(精确搜索)
   */
  private List<String> buyerMessageInList;

  /**
   * 货币(模糊搜索)
   */
  private String currency;

  /**
   * 货币 比较(eq)
   */
  private String currencyEq;
  /**
   * 货币 比较(neq)
   */
  private String currencyNeq;
  /**
   * 货币 比较(gt)
   */
  private String currencyGt;
  /**
   * 货币 比较(gte)
   */
  private String currencyGte;
  /**
   * 货币 比较(lt)
   */
  private String currencyLt;
  /**
   * 货币 比较(lte)
   */
  private String currencyLte;
  /**
   * 货币 比较(contains)
   */
  private String currencyContains;
  /**
   * 货币 比较(notcontains)
   */
  private String currencyNotcontains;
  /**
   * 货币 比较(startswith)
   */
  private String currencyStartswith;
  /**
   * 货币 比较(endswith)
   */
  private String currencyEndswith;
  /**
   * 货币 比较(isnull)
   */
  private Boolean currencyIsnull;
  /**
   * 货币 比较(isnotnull)
   */
  private Boolean currencyIsnotnull;

  /**
   * 货币(精确搜索)
   */
  private List<String> currencyInList;

  /**
   * 订单商品总额
   */
  private java.math.BigDecimal subTotal;

  /**
   * 最小订单商品总额
   */
  private java.math.BigDecimal subTotalMin;

  /**
   * 最大订单商品总额
   */
  private java.math.BigDecimal subTotalMax;

  /**
   * 订单商品总额 比较(eq)
   */
  private java.math.BigDecimal subTotalEq;
  /**
   * 订单商品总额 比较(neq)
   */
  private java.math.BigDecimal subTotalNeq;
  /**
   * 订单商品总额 比较(gt)
   */
  private java.math.BigDecimal subTotalGt;
  /**
   * 订单商品总额 比较(gte)
   */
  private java.math.BigDecimal subTotalGte;
  /**
   * 订单商品总额 比较(lt)
   */
  private java.math.BigDecimal subTotalLt;
  /**
   * 订单商品总额 比较(lte)
   */
  private java.math.BigDecimal subTotalLte;
  /**
   * 订单商品总额 比较(contains)
   */
  private java.math.BigDecimal subTotalContains;
  /**
   * 订单商品总额 比较(notcontains)
   */
  private java.math.BigDecimal subTotalNotcontains;
  /**
   * 订单商品总额 比较(startswith)
   */
  private java.math.BigDecimal subTotalStartswith;
  /**
   * 订单商品总额 比较(endswith)
   */
  private java.math.BigDecimal subTotalEndswith;
  /**
   * 订单商品总额 比较(isnull)
   */
  private Boolean subTotalIsnull;
  /**
   * 订单商品总额 比较(isnotnull)
   */
  private Boolean subTotalIsnotnull;

  /**
   * 支付运费
   */
  private java.math.BigDecimal shippingFee;

  /**
   * 最小支付运费
   */
  private java.math.BigDecimal shippingFeeMin;

  /**
   * 最大支付运费
   */
  private java.math.BigDecimal shippingFeeMax;

  /**
   * 支付运费 比较(eq)
   */
  private java.math.BigDecimal shippingFeeEq;
  /**
   * 支付运费 比较(neq)
   */
  private java.math.BigDecimal shippingFeeNeq;
  /**
   * 支付运费 比较(gt)
   */
  private java.math.BigDecimal shippingFeeGt;
  /**
   * 支付运费 比较(gte)
   */
  private java.math.BigDecimal shippingFeeGte;
  /**
   * 支付运费 比较(lt)
   */
  private java.math.BigDecimal shippingFeeLt;
  /**
   * 支付运费 比较(lte)
   */
  private java.math.BigDecimal shippingFeeLte;
  /**
   * 支付运费 比较(contains)
   */
  private java.math.BigDecimal shippingFeeContains;
  /**
   * 支付运费 比较(notcontains)
   */
  private java.math.BigDecimal shippingFeeNotcontains;
  /**
   * 支付运费 比较(startswith)
   */
  private java.math.BigDecimal shippingFeeStartswith;
  /**
   * 支付运费 比较(endswith)
   */
  private java.math.BigDecimal shippingFeeEndswith;
  /**
   * 支付运费 比较(isnull)
   */
  private Boolean shippingFeeIsnull;
  /**
   * 支付运费 比较(isnotnull)
   */
  private Boolean shippingFeeIsnotnull;

  /**
   * 卖方折扣金额
   */
  private java.math.BigDecimal sellerDiscount;

  /**
   * 最小卖方折扣金额
   */
  private java.math.BigDecimal sellerDiscountMin;

  /**
   * 最大卖方折扣金额
   */
  private java.math.BigDecimal sellerDiscountMax;

  /**
   * 卖方折扣金额 比较(eq)
   */
  private java.math.BigDecimal sellerDiscountEq;
  /**
   * 卖方折扣金额 比较(neq)
   */
  private java.math.BigDecimal sellerDiscountNeq;
  /**
   * 卖方折扣金额 比较(gt)
   */
  private java.math.BigDecimal sellerDiscountGt;
  /**
   * 卖方折扣金额 比较(gte)
   */
  private java.math.BigDecimal sellerDiscountGte;
  /**
   * 卖方折扣金额 比较(lt)
   */
  private java.math.BigDecimal sellerDiscountLt;
  /**
   * 卖方折扣金额 比较(lte)
   */
  private java.math.BigDecimal sellerDiscountLte;
  /**
   * 卖方折扣金额 比较(contains)
   */
  private java.math.BigDecimal sellerDiscountContains;
  /**
   * 卖方折扣金额 比较(notcontains)
   */
  private java.math.BigDecimal sellerDiscountNotcontains;
  /**
   * 卖方折扣金额 比较(startswith)
   */
  private java.math.BigDecimal sellerDiscountStartswith;
  /**
   * 卖方折扣金额 比较(endswith)
   */
  private java.math.BigDecimal sellerDiscountEndswith;
  /**
   * 卖方折扣金额 比较(isnull)
   */
  private Boolean sellerDiscountIsnull;
  /**
   * 卖方折扣金额 比较(isnotnull)
   */
  private Boolean sellerDiscountIsnotnull;

  /**
   * 平台折扣金额
   */
  private java.math.BigDecimal platformDiscount;

  /**
   * 最小平台折扣金额
   */
  private java.math.BigDecimal platformDiscountMin;

  /**
   * 最大平台折扣金额
   */
  private java.math.BigDecimal platformDiscountMax;

  /**
   * 平台折扣金额 比较(eq)
   */
  private java.math.BigDecimal platformDiscountEq;
  /**
   * 平台折扣金额 比较(neq)
   */
  private java.math.BigDecimal platformDiscountNeq;
  /**
   * 平台折扣金额 比较(gt)
   */
  private java.math.BigDecimal platformDiscountGt;
  /**
   * 平台折扣金额 比较(gte)
   */
  private java.math.BigDecimal platformDiscountGte;
  /**
   * 平台折扣金额 比较(lt)
   */
  private java.math.BigDecimal platformDiscountLt;
  /**
   * 平台折扣金额 比较(lte)
   */
  private java.math.BigDecimal platformDiscountLte;
  /**
   * 平台折扣金额 比较(contains)
   */
  private java.math.BigDecimal platformDiscountContains;
  /**
   * 平台折扣金额 比较(notcontains)
   */
  private java.math.BigDecimal platformDiscountNotcontains;
  /**
   * 平台折扣金额 比较(startswith)
   */
  private java.math.BigDecimal platformDiscountStartswith;
  /**
   * 平台折扣金额 比较(endswith)
   */
  private java.math.BigDecimal platformDiscountEndswith;
  /**
   * 平台折扣金额 比较(isnull)
   */
  private Boolean platformDiscountIsnull;
  /**
   * 平台折扣金额 比较(isnotnull)
   */
  private Boolean platformDiscountIsnotnull;

  /**
   * 买方支付金额
   */
  private java.math.BigDecimal totalAmount;

  /**
   * 最小买方支付金额
   */
  private java.math.BigDecimal totalAmountMin;

  /**
   * 最大买方支付金额
   */
  private java.math.BigDecimal totalAmountMax;

  /**
   * 买方支付金额 比较(eq)
   */
  private java.math.BigDecimal totalAmountEq;
  /**
   * 买方支付金额 比较(neq)
   */
  private java.math.BigDecimal totalAmountNeq;
  /**
   * 买方支付金额 比较(gt)
   */
  private java.math.BigDecimal totalAmountGt;
  /**
   * 买方支付金额 比较(gte)
   */
  private java.math.BigDecimal totalAmountGte;
  /**
   * 买方支付金额 比较(lt)
   */
  private java.math.BigDecimal totalAmountLt;
  /**
   * 买方支付金额 比较(lte)
   */
  private java.math.BigDecimal totalAmountLte;
  /**
   * 买方支付金额 比较(contains)
   */
  private java.math.BigDecimal totalAmountContains;
  /**
   * 买方支付金额 比较(notcontains)
   */
  private java.math.BigDecimal totalAmountNotcontains;
  /**
   * 买方支付金额 比较(startswith)
   */
  private java.math.BigDecimal totalAmountStartswith;
  /**
   * 买方支付金额 比较(endswith)
   */
  private java.math.BigDecimal totalAmountEndswith;
  /**
   * 买方支付金额 比较(isnull)
   */
  private Boolean totalAmountIsnull;
  /**
   * 买方支付金额 比较(isnotnull)
   */
  private Boolean totalAmountIsnotnull;

  /**
   * 产品原价总额
   */
  private java.math.BigDecimal originalTotalProductPrice;

  /**
   * 最小产品原价总额
   */
  private java.math.BigDecimal originalTotalProductPriceMin;

  /**
   * 最大产品原价总额
   */
  private java.math.BigDecimal originalTotalProductPriceMax;

  /**
   * 产品原价总额 比较(eq)
   */
  private java.math.BigDecimal originalTotalProductPriceEq;
  /**
   * 产品原价总额 比较(neq)
   */
  private java.math.BigDecimal originalTotalProductPriceNeq;
  /**
   * 产品原价总额 比较(gt)
   */
  private java.math.BigDecimal originalTotalProductPriceGt;
  /**
   * 产品原价总额 比较(gte)
   */
  private java.math.BigDecimal originalTotalProductPriceGte;
  /**
   * 产品原价总额 比较(lt)
   */
  private java.math.BigDecimal originalTotalProductPriceLt;
  /**
   * 产品原价总额 比较(lte)
   */
  private java.math.BigDecimal originalTotalProductPriceLte;
  /**
   * 产品原价总额 比较(contains)
   */
  private java.math.BigDecimal originalTotalProductPriceContains;
  /**
   * 产品原价总额 比较(notcontains)
   */
  private java.math.BigDecimal originalTotalProductPriceNotcontains;
  /**
   * 产品原价总额 比较(startswith)
   */
  private java.math.BigDecimal originalTotalProductPriceStartswith;
  /**
   * 产品原价总额 比较(endswith)
   */
  private java.math.BigDecimal originalTotalProductPriceEndswith;
  /**
   * 产品原价总额 比较(isnull)
   */
  private Boolean originalTotalProductPriceIsnull;
  /**
   * 产品原价总额 比较(isnotnull)
   */
  private Boolean originalTotalProductPriceIsnotnull;

  /**
   * 折扣前运费
   */
  private java.math.BigDecimal originalShippingFee;

  /**
   * 最小折扣前运费
   */
  private java.math.BigDecimal originalShippingFeeMin;

  /**
   * 最大折扣前运费
   */
  private java.math.BigDecimal originalShippingFeeMax;

  /**
   * 折扣前运费 比较(eq)
   */
  private java.math.BigDecimal originalShippingFeeEq;
  /**
   * 折扣前运费 比较(neq)
   */
  private java.math.BigDecimal originalShippingFeeNeq;
  /**
   * 折扣前运费 比较(gt)
   */
  private java.math.BigDecimal originalShippingFeeGt;
  /**
   * 折扣前运费 比较(gte)
   */
  private java.math.BigDecimal originalShippingFeeGte;
  /**
   * 折扣前运费 比较(lt)
   */
  private java.math.BigDecimal originalShippingFeeLt;
  /**
   * 折扣前运费 比较(lte)
   */
  private java.math.BigDecimal originalShippingFeeLte;
  /**
   * 折扣前运费 比较(contains)
   */
  private java.math.BigDecimal originalShippingFeeContains;
  /**
   * 折扣前运费 比较(notcontains)
   */
  private java.math.BigDecimal originalShippingFeeNotcontains;
  /**
   * 折扣前运费 比较(startswith)
   */
  private java.math.BigDecimal originalShippingFeeStartswith;
  /**
   * 折扣前运费 比较(endswith)
   */
  private java.math.BigDecimal originalShippingFeeEndswith;
  /**
   * 折扣前运费 比较(isnull)
   */
  private Boolean originalShippingFeeIsnull;
  /**
   * 折扣前运费 比较(isnotnull)
   */
  private Boolean originalShippingFeeIsnotnull;

  /**
   * 卖方折扣运费
   */
  private java.math.BigDecimal shippingFeeSellerDiscount;

  /**
   * 最小卖方折扣运费
   */
  private java.math.BigDecimal shippingFeeSellerDiscountMin;

  /**
   * 最大卖方折扣运费
   */
  private java.math.BigDecimal shippingFeeSellerDiscountMax;

  /**
   * 卖方折扣运费 比较(eq)
   */
  private java.math.BigDecimal shippingFeeSellerDiscountEq;
  /**
   * 卖方折扣运费 比较(neq)
   */
  private java.math.BigDecimal shippingFeeSellerDiscountNeq;
  /**
   * 卖方折扣运费 比较(gt)
   */
  private java.math.BigDecimal shippingFeeSellerDiscountGt;
  /**
   * 卖方折扣运费 比较(gte)
   */
  private java.math.BigDecimal shippingFeeSellerDiscountGte;
  /**
   * 卖方折扣运费 比较(lt)
   */
  private java.math.BigDecimal shippingFeeSellerDiscountLt;
  /**
   * 卖方折扣运费 比较(lte)
   */
  private java.math.BigDecimal shippingFeeSellerDiscountLte;
  /**
   * 卖方折扣运费 比较(contains)
   */
  private java.math.BigDecimal shippingFeeSellerDiscountContains;
  /**
   * 卖方折扣运费 比较(notcontains)
   */
  private java.math.BigDecimal shippingFeeSellerDiscountNotcontains;
  /**
   * 卖方折扣运费 比较(startswith)
   */
  private java.math.BigDecimal shippingFeeSellerDiscountStartswith;
  /**
   * 卖方折扣运费 比较(endswith)
   */
  private java.math.BigDecimal shippingFeeSellerDiscountEndswith;
  /**
   * 卖方折扣运费 比较(isnull)
   */
  private Boolean shippingFeeSellerDiscountIsnull;
  /**
   * 卖方折扣运费 比较(isnotnull)
   */
  private Boolean shippingFeeSellerDiscountIsnotnull;

  /**
   * 平台折扣运费
   */
  private java.math.BigDecimal shippingFeePlatformDiscount;

  /**
   * 最小平台折扣运费
   */
  private java.math.BigDecimal shippingFeePlatformDiscountMin;

  /**
   * 最大平台折扣运费
   */
  private java.math.BigDecimal shippingFeePlatformDiscountMax;

  /**
   * 平台折扣运费 比较(eq)
   */
  private java.math.BigDecimal shippingFeePlatformDiscountEq;
  /**
   * 平台折扣运费 比较(neq)
   */
  private java.math.BigDecimal shippingFeePlatformDiscountNeq;
  /**
   * 平台折扣运费 比较(gt)
   */
  private java.math.BigDecimal shippingFeePlatformDiscountGt;
  /**
   * 平台折扣运费 比较(gte)
   */
  private java.math.BigDecimal shippingFeePlatformDiscountGte;
  /**
   * 平台折扣运费 比较(lt)
   */
  private java.math.BigDecimal shippingFeePlatformDiscountLt;
  /**
   * 平台折扣运费 比较(lte)
   */
  private java.math.BigDecimal shippingFeePlatformDiscountLte;
  /**
   * 平台折扣运费 比较(contains)
   */
  private java.math.BigDecimal shippingFeePlatformDiscountContains;
  /**
   * 平台折扣运费 比较(notcontains)
   */
  private java.math.BigDecimal shippingFeePlatformDiscountNotcontains;
  /**
   * 平台折扣运费 比较(startswith)
   */
  private java.math.BigDecimal shippingFeePlatformDiscountStartswith;
  /**
   * 平台折扣运费 比较(endswith)
   */
  private java.math.BigDecimal shippingFeePlatformDiscountEndswith;
  /**
   * 平台折扣运费 比较(isnull)
   */
  private Boolean shippingFeePlatformDiscountIsnull;
  /**
   * 平台折扣运费 比较(isnotnull)
   */
  private Boolean shippingFeePlatformDiscountIsnotnull;

  /**
   * 税款总额
   */
  private java.math.BigDecimal tax;

  /**
   * 最小税款总额
   */
  private java.math.BigDecimal taxMin;

  /**
   * 最大税款总额
   */
  private java.math.BigDecimal taxMax;

  /**
   * 税款总额 比较(eq)
   */
  private java.math.BigDecimal taxEq;
  /**
   * 税款总额 比较(neq)
   */
  private java.math.BigDecimal taxNeq;
  /**
   * 税款总额 比较(gt)
   */
  private java.math.BigDecimal taxGt;
  /**
   * 税款总额 比较(gte)
   */
  private java.math.BigDecimal taxGte;
  /**
   * 税款总额 比较(lt)
   */
  private java.math.BigDecimal taxLt;
  /**
   * 税款总额 比较(lte)
   */
  private java.math.BigDecimal taxLte;
  /**
   * 税款总额 比较(contains)
   */
  private java.math.BigDecimal taxContains;
  /**
   * 税款总额 比较(notcontains)
   */
  private java.math.BigDecimal taxNotcontains;
  /**
   * 税款总额 比较(startswith)
   */
  private java.math.BigDecimal taxStartswith;
  /**
   * 税款总额 比较(endswith)
   */
  private java.math.BigDecimal taxEndswith;
  /**
   * 税款总额 比较(isnull)
   */
  private Boolean taxIsnull;
  /**
   * 税款总额 比较(isnotnull)
   */
  private Boolean taxIsnotnull;

  /**
   * 小订单费
   */
  private java.math.BigDecimal smallOrderFee;

  /**
   * 最小小订单费
   */
  private java.math.BigDecimal smallOrderFeeMin;

  /**
   * 最大小订单费
   */
  private java.math.BigDecimal smallOrderFeeMax;

  /**
   * 小订单费 比较(eq)
   */
  private java.math.BigDecimal smallOrderFeeEq;
  /**
   * 小订单费 比较(neq)
   */
  private java.math.BigDecimal smallOrderFeeNeq;
  /**
   * 小订单费 比较(gt)
   */
  private java.math.BigDecimal smallOrderFeeGt;
  /**
   * 小订单费 比较(gte)
   */
  private java.math.BigDecimal smallOrderFeeGte;
  /**
   * 小订单费 比较(lt)
   */
  private java.math.BigDecimal smallOrderFeeLt;
  /**
   * 小订单费 比较(lte)
   */
  private java.math.BigDecimal smallOrderFeeLte;
  /**
   * 小订单费 比较(contains)
   */
  private java.math.BigDecimal smallOrderFeeContains;
  /**
   * 小订单费 比较(notcontains)
   */
  private java.math.BigDecimal smallOrderFeeNotcontains;
  /**
   * 小订单费 比较(startswith)
   */
  private java.math.BigDecimal smallOrderFeeStartswith;
  /**
   * 小订单费 比较(endswith)
   */
  private java.math.BigDecimal smallOrderFeeEndswith;
  /**
   * 小订单费 比较(isnull)
   */
  private Boolean smallOrderFeeIsnull;
  /**
   * 小订单费 比较(isnotnull)
   */
  private Boolean smallOrderFeeIsnotnull;

  /**
   * 运费税
   */
  private java.math.BigDecimal shippingFeeTax;

  /**
   * 最小运费税
   */
  private java.math.BigDecimal shippingFeeTaxMin;

  /**
   * 最大运费税
   */
  private java.math.BigDecimal shippingFeeTaxMax;

  /**
   * 运费税 比较(eq)
   */
  private java.math.BigDecimal shippingFeeTaxEq;
  /**
   * 运费税 比较(neq)
   */
  private java.math.BigDecimal shippingFeeTaxNeq;
  /**
   * 运费税 比较(gt)
   */
  private java.math.BigDecimal shippingFeeTaxGt;
  /**
   * 运费税 比较(gte)
   */
  private java.math.BigDecimal shippingFeeTaxGte;
  /**
   * 运费税 比较(lt)
   */
  private java.math.BigDecimal shippingFeeTaxLt;
  /**
   * 运费税 比较(lte)
   */
  private java.math.BigDecimal shippingFeeTaxLte;
  /**
   * 运费税 比较(contains)
   */
  private java.math.BigDecimal shippingFeeTaxContains;
  /**
   * 运费税 比较(notcontains)
   */
  private java.math.BigDecimal shippingFeeTaxNotcontains;
  /**
   * 运费税 比较(startswith)
   */
  private java.math.BigDecimal shippingFeeTaxStartswith;
  /**
   * 运费税 比较(endswith)
   */
  private java.math.BigDecimal shippingFeeTaxEndswith;
  /**
   * 运费税 比较(isnull)
   */
  private Boolean shippingFeeTaxIsnull;
  /**
   * 运费税 比较(isnotnull)
   */
  private Boolean shippingFeeTaxIsnotnull;

  /**
   * 商品税
   */
  private java.math.BigDecimal productTax;

  /**
   * 最小商品税
   */
  private java.math.BigDecimal productTaxMin;

  /**
   * 最大商品税
   */
  private java.math.BigDecimal productTaxMax;

  /**
   * 商品税 比较(eq)
   */
  private java.math.BigDecimal productTaxEq;
  /**
   * 商品税 比较(neq)
   */
  private java.math.BigDecimal productTaxNeq;
  /**
   * 商品税 比较(gt)
   */
  private java.math.BigDecimal productTaxGt;
  /**
   * 商品税 比较(gte)
   */
  private java.math.BigDecimal productTaxGte;
  /**
   * 商品税 比较(lt)
   */
  private java.math.BigDecimal productTaxLt;
  /**
   * 商品税 比较(lte)
   */
  private java.math.BigDecimal productTaxLte;
  /**
   * 商品税 比较(contains)
   */
  private java.math.BigDecimal productTaxContains;
  /**
   * 商品税 比较(notcontains)
   */
  private java.math.BigDecimal productTaxNotcontains;
  /**
   * 商品税 比较(startswith)
   */
  private java.math.BigDecimal productTaxStartswith;
  /**
   * 商品税 比较(endswith)
   */
  private java.math.BigDecimal productTaxEndswith;
  /**
   * 商品税 比较(isnull)
   */
  private Boolean productTaxIsnull;
  /**
   * 商品税 比较(isnotnull)
   */
  private Boolean productTaxIsnotnull;

  /**
   * RDF(零售配送费)
   */
  private java.math.BigDecimal retailDeliveryFee;

  /**
   * 最小RDF(零售配送费)
   */
  private java.math.BigDecimal retailDeliveryFeeMin;

  /**
   * 最大RDF(零售配送费)
   */
  private java.math.BigDecimal retailDeliveryFeeMax;

  /**
   * RDF(零售配送费) 比较(eq)
   */
  private java.math.BigDecimal retailDeliveryFeeEq;
  /**
   * RDF(零售配送费) 比较(neq)
   */
  private java.math.BigDecimal retailDeliveryFeeNeq;
  /**
   * RDF(零售配送费) 比较(gt)
   */
  private java.math.BigDecimal retailDeliveryFeeGt;
  /**
   * RDF(零售配送费) 比较(gte)
   */
  private java.math.BigDecimal retailDeliveryFeeGte;
  /**
   * RDF(零售配送费) 比较(lt)
   */
  private java.math.BigDecimal retailDeliveryFeeLt;
  /**
   * RDF(零售配送费) 比较(lte)
   */
  private java.math.BigDecimal retailDeliveryFeeLte;
  /**
   * RDF(零售配送费) 比较(contains)
   */
  private java.math.BigDecimal retailDeliveryFeeContains;
  /**
   * RDF(零售配送费) 比较(notcontains)
   */
  private java.math.BigDecimal retailDeliveryFeeNotcontains;
  /**
   * RDF(零售配送费) 比较(startswith)
   */
  private java.math.BigDecimal retailDeliveryFeeStartswith;
  /**
   * RDF(零售配送费) 比较(endswith)
   */
  private java.math.BigDecimal retailDeliveryFeeEndswith;
  /**
   * RDF(零售配送费) 比较(isnull)
   */
  private Boolean retailDeliveryFeeIsnull;
  /**
   * RDF(零售配送费) 比较(isnotnull)
   */
  private Boolean retailDeliveryFeeIsnotnull;

  /**
   * 完整的收件人地址信息(模糊搜索)
   */
  private String fullAddress;

  /**
   * 完整的收件人地址信息 比较(eq)
   */
  private String fullAddressEq;
  /**
   * 完整的收件人地址信息 比较(neq)
   */
  private String fullAddressNeq;
  /**
   * 完整的收件人地址信息 比较(gt)
   */
  private String fullAddressGt;
  /**
   * 完整的收件人地址信息 比较(gte)
   */
  private String fullAddressGte;
  /**
   * 完整的收件人地址信息 比较(lt)
   */
  private String fullAddressLt;
  /**
   * 完整的收件人地址信息 比较(lte)
   */
  private String fullAddressLte;
  /**
   * 完整的收件人地址信息 比较(contains)
   */
  private String fullAddressContains;
  /**
   * 完整的收件人地址信息 比较(notcontains)
   */
  private String fullAddressNotcontains;
  /**
   * 完整的收件人地址信息 比较(startswith)
   */
  private String fullAddressStartswith;
  /**
   * 完整的收件人地址信息 比较(endswith)
   */
  private String fullAddressEndswith;
  /**
   * 完整的收件人地址信息 比较(isnull)
   */
  private Boolean fullAddressIsnull;
  /**
   * 完整的收件人地址信息 比较(isnotnull)
   */
  private Boolean fullAddressIsnotnull;

  /**
   * 完整的收件人地址信息(精确搜索)
   */
  private List<String> fullAddressInList;

  /**
   * 收件人手机号(模糊搜索)
   */
  private String phoneNumber;

  /**
   * 收件人手机号 比较(eq)
   */
  private String phoneNumberEq;
  /**
   * 收件人手机号 比较(neq)
   */
  private String phoneNumberNeq;
  /**
   * 收件人手机号 比较(gt)
   */
  private String phoneNumberGt;
  /**
   * 收件人手机号 比较(gte)
   */
  private String phoneNumberGte;
  /**
   * 收件人手机号 比较(lt)
   */
  private String phoneNumberLt;
  /**
   * 收件人手机号 比较(lte)
   */
  private String phoneNumberLte;
  /**
   * 收件人手机号 比较(contains)
   */
  private String phoneNumberContains;
  /**
   * 收件人手机号 比较(notcontains)
   */
  private String phoneNumberNotcontains;
  /**
   * 收件人手机号 比较(startswith)
   */
  private String phoneNumberStartswith;
  /**
   * 收件人手机号 比较(endswith)
   */
  private String phoneNumberEndswith;
  /**
   * 收件人手机号 比较(isnull)
   */
  private Boolean phoneNumberIsnull;
  /**
   * 收件人手机号 比较(isnotnull)
   */
  private Boolean phoneNumberIsnotnull;

  /**
   * 收件人手机号(精确搜索)
   */
  private List<String> phoneNumberInList;

  /**
   * 收件人名称(模糊搜索)
   */
  private String name;

  /**
   * 收件人名称 比较(eq)
   */
  private String nameEq;
  /**
   * 收件人名称 比较(neq)
   */
  private String nameNeq;
  /**
   * 收件人名称 比较(gt)
   */
  private String nameGt;
  /**
   * 收件人名称 比较(gte)
   */
  private String nameGte;
  /**
   * 收件人名称 比较(lt)
   */
  private String nameLt;
  /**
   * 收件人名称 比较(lte)
   */
  private String nameLte;
  /**
   * 收件人名称 比较(contains)
   */
  private String nameContains;
  /**
   * 收件人名称 比较(notcontains)
   */
  private String nameNotcontains;
  /**
   * 收件人名称 比较(startswith)
   */
  private String nameStartswith;
  /**
   * 收件人名称 比较(endswith)
   */
  private String nameEndswith;
  /**
   * 收件人名称 比较(isnull)
   */
  private Boolean nameIsnull;
  /**
   * 收件人名称 比较(isnotnull)
   */
  private Boolean nameIsnotnull;

  /**
   * 收件人名称(精确搜索)
   */
  private List<String> nameInList;

  /**
   * 邮编号码(模糊搜索)
   */
  private String postalCode;

  /**
   * 邮编号码 比较(eq)
   */
  private String postalCodeEq;
  /**
   * 邮编号码 比较(neq)
   */
  private String postalCodeNeq;
  /**
   * 邮编号码 比较(gt)
   */
  private String postalCodeGt;
  /**
   * 邮编号码 比较(gte)
   */
  private String postalCodeGte;
  /**
   * 邮编号码 比较(lt)
   */
  private String postalCodeLt;
  /**
   * 邮编号码 比较(lte)
   */
  private String postalCodeLte;
  /**
   * 邮编号码 比较(contains)
   */
  private String postalCodeContains;
  /**
   * 邮编号码 比较(notcontains)
   */
  private String postalCodeNotcontains;
  /**
   * 邮编号码 比较(startswith)
   */
  private String postalCodeStartswith;
  /**
   * 邮编号码 比较(endswith)
   */
  private String postalCodeEndswith;
  /**
   * 邮编号码 比较(isnull)
   */
  private Boolean postalCodeIsnull;
  /**
   * 邮编号码 比较(isnotnull)
   */
  private Boolean postalCodeIsnotnull;

  /**
   * 邮编号码(精确搜索)
   */
  private List<String> postalCodeInList;

  /**
   * 详细地址(模糊搜索)
   */
  private String addressDetail;

  /**
   * 详细地址 比较(eq)
   */
  private String addressDetailEq;
  /**
   * 详细地址 比较(neq)
   */
  private String addressDetailNeq;
  /**
   * 详细地址 比较(gt)
   */
  private String addressDetailGt;
  /**
   * 详细地址 比较(gte)
   */
  private String addressDetailGte;
  /**
   * 详细地址 比较(lt)
   */
  private String addressDetailLt;
  /**
   * 详细地址 比较(lte)
   */
  private String addressDetailLte;
  /**
   * 详细地址 比较(contains)
   */
  private String addressDetailContains;
  /**
   * 详细地址 比较(notcontains)
   */
  private String addressDetailNotcontains;
  /**
   * 详细地址 比较(startswith)
   */
  private String addressDetailStartswith;
  /**
   * 详细地址 比较(endswith)
   */
  private String addressDetailEndswith;
  /**
   * 详细地址 比较(isnull)
   */
  private Boolean addressDetailIsnull;
  /**
   * 详细地址 比较(isnotnull)
   */
  private Boolean addressDetailIsnotnull;

  /**
   * 详细地址(精确搜索)
   */
  private List<String> addressDetailInList;

  /**
   * 区域编码(模糊搜索)
   */
  private String regionCode;

  /**
   * 区域编码 比较(eq)
   */
  private String regionCodeEq;
  /**
   * 区域编码 比较(neq)
   */
  private String regionCodeNeq;
  /**
   * 区域编码 比较(gt)
   */
  private String regionCodeGt;
  /**
   * 区域编码 比较(gte)
   */
  private String regionCodeGte;
  /**
   * 区域编码 比较(lt)
   */
  private String regionCodeLt;
  /**
   * 区域编码 比较(lte)
   */
  private String regionCodeLte;
  /**
   * 区域编码 比较(contains)
   */
  private String regionCodeContains;
  /**
   * 区域编码 比较(notcontains)
   */
  private String regionCodeNotcontains;
  /**
   * 区域编码 比较(startswith)
   */
  private String regionCodeStartswith;
  /**
   * 区域编码 比较(endswith)
   */
  private String regionCodeEndswith;
  /**
   * 区域编码 比较(isnull)
   */
  private Boolean regionCodeIsnull;
  /**
   * 区域编码 比较(isnotnull)
   */
  private Boolean regionCodeIsnotnull;

  /**
   * 区域编码(精确搜索)
   */
  private List<String> regionCodeInList;

  /**
   * 街道地址1(模糊搜索)
   */
  private String addressLine1;

  /**
   * 街道地址1 比较(eq)
   */
  private String addressLine1Eq;
  /**
   * 街道地址1 比较(neq)
   */
  private String addressLine1Neq;
  /**
   * 街道地址1 比较(gt)
   */
  private String addressLine1Gt;
  /**
   * 街道地址1 比较(gte)
   */
  private String addressLine1Gte;
  /**
   * 街道地址1 比较(lt)
   */
  private String addressLine1Lt;
  /**
   * 街道地址1 比较(lte)
   */
  private String addressLine1Lte;
  /**
   * 街道地址1 比较(contains)
   */
  private String addressLine1Contains;
  /**
   * 街道地址1 比较(notcontains)
   */
  private String addressLine1Notcontains;
  /**
   * 街道地址1 比较(startswith)
   */
  private String addressLine1Startswith;
  /**
   * 街道地址1 比较(endswith)
   */
  private String addressLine1Endswith;
  /**
   * 街道地址1 比较(isnull)
   */
  private Boolean addressLine1Isnull;
  /**
   * 街道地址1 比较(isnotnull)
   */
  private Boolean addressLine1Isnotnull;

  /**
   * 街道地址1(精确搜索)
   */
  private List<String> addressLine1InList;

  /**
   * 街道地址2(模糊搜索)
   */
  private String addressLine2;

  /**
   * 街道地址2 比较(eq)
   */
  private String addressLine2Eq;
  /**
   * 街道地址2 比较(neq)
   */
  private String addressLine2Neq;
  /**
   * 街道地址2 比较(gt)
   */
  private String addressLine2Gt;
  /**
   * 街道地址2 比较(gte)
   */
  private String addressLine2Gte;
  /**
   * 街道地址2 比较(lt)
   */
  private String addressLine2Lt;
  /**
   * 街道地址2 比较(lte)
   */
  private String addressLine2Lte;
  /**
   * 街道地址2 比较(contains)
   */
  private String addressLine2Contains;
  /**
   * 街道地址2 比较(notcontains)
   */
  private String addressLine2Notcontains;
  /**
   * 街道地址2 比较(startswith)
   */
  private String addressLine2Startswith;
  /**
   * 街道地址2 比较(endswith)
   */
  private String addressLine2Endswith;
  /**
   * 街道地址2 比较(isnull)
   */
  private Boolean addressLine2Isnull;
  /**
   * 街道地址2 比较(isnotnull)
   */
  private Boolean addressLine2Isnotnull;

  /**
   * 街道地址2(精确搜索)
   */
  private List<String> addressLine2InList;

  /**
   * 街道地址3(模糊搜索)
   */
  private String addressLine3;

  /**
   * 街道地址3 比较(eq)
   */
  private String addressLine3Eq;
  /**
   * 街道地址3 比较(neq)
   */
  private String addressLine3Neq;
  /**
   * 街道地址3 比较(gt)
   */
  private String addressLine3Gt;
  /**
   * 街道地址3 比较(gte)
   */
  private String addressLine3Gte;
  /**
   * 街道地址3 比较(lt)
   */
  private String addressLine3Lt;
  /**
   * 街道地址3 比较(lte)
   */
  private String addressLine3Lte;
  /**
   * 街道地址3 比较(contains)
   */
  private String addressLine3Contains;
  /**
   * 街道地址3 比较(notcontains)
   */
  private String addressLine3Notcontains;
  /**
   * 街道地址3 比较(startswith)
   */
  private String addressLine3Startswith;
  /**
   * 街道地址3 比较(endswith)
   */
  private String addressLine3Endswith;
  /**
   * 街道地址3 比较(isnull)
   */
  private Boolean addressLine3Isnull;
  /**
   * 街道地址3 比较(isnotnull)
   */
  private Boolean addressLine3Isnotnull;

  /**
   * 街道地址3(精确搜索)
   */
  private List<String> addressLine3InList;

  /**
   * 街道地址4(模糊搜索)
   */
  private String addressLine4;

  /**
   * 街道地址4 比较(eq)
   */
  private String addressLine4Eq;
  /**
   * 街道地址4 比较(neq)
   */
  private String addressLine4Neq;
  /**
   * 街道地址4 比较(gt)
   */
  private String addressLine4Gt;
  /**
   * 街道地址4 比较(gte)
   */
  private String addressLine4Gte;
  /**
   * 街道地址4 比较(lt)
   */
  private String addressLine4Lt;
  /**
   * 街道地址4 比较(lte)
   */
  private String addressLine4Lte;
  /**
   * 街道地址4 比较(contains)
   */
  private String addressLine4Contains;
  /**
   * 街道地址4 比较(notcontains)
   */
  private String addressLine4Notcontains;
  /**
   * 街道地址4 比较(startswith)
   */
  private String addressLine4Startswith;
  /**
   * 街道地址4 比较(endswith)
   */
  private String addressLine4Endswith;
  /**
   * 街道地址4 比较(isnull)
   */
  private Boolean addressLine4Isnull;
  /**
   * 街道地址4 比较(isnotnull)
   */
  private Boolean addressLine4Isnotnull;

  /**
   * 街道地址4(精确搜索)
   */
  private List<String> addressLine4InList;

  /**
   * 国家(模糊搜索)
   */
  private String country;

  /**
   * 国家 比较(eq)
   */
  private String countryEq;
  /**
   * 国家 比较(neq)
   */
  private String countryNeq;
  /**
   * 国家 比较(gt)
   */
  private String countryGt;
  /**
   * 国家 比较(gte)
   */
  private String countryGte;
  /**
   * 国家 比较(lt)
   */
  private String countryLt;
  /**
   * 国家 比较(lte)
   */
  private String countryLte;
  /**
   * 国家 比较(contains)
   */
  private String countryContains;
  /**
   * 国家 比较(notcontains)
   */
  private String countryNotcontains;
  /**
   * 国家 比较(startswith)
   */
  private String countryStartswith;
  /**
   * 国家 比较(endswith)
   */
  private String countryEndswith;
  /**
   * 国家 比较(isnull)
   */
  private Boolean countryIsnull;
  /**
   * 国家 比较(isnotnull)
   */
  private Boolean countryIsnotnull;

  /**
   * 国家(精确搜索)
   */
  private List<String> countryInList;

  /**
   * 州(模糊搜索)
   */
  private String addressState;

  /**
   * 州 比较(eq)
   */
  private String addressStateEq;
  /**
   * 州 比较(neq)
   */
  private String addressStateNeq;
  /**
   * 州 比较(gt)
   */
  private String addressStateGt;
  /**
   * 州 比较(gte)
   */
  private String addressStateGte;
  /**
   * 州 比较(lt)
   */
  private String addressStateLt;
  /**
   * 州 比较(lte)
   */
  private String addressStateLte;
  /**
   * 州 比较(contains)
   */
  private String addressStateContains;
  /**
   * 州 比较(notcontains)
   */
  private String addressStateNotcontains;
  /**
   * 州 比较(startswith)
   */
  private String addressStateStartswith;
  /**
   * 州 比较(endswith)
   */
  private String addressStateEndswith;
  /**
   * 州 比较(isnull)
   */
  private Boolean addressStateIsnull;
  /**
   * 州 比较(isnotnull)
   */
  private Boolean addressStateIsnotnull;

  /**
   * 州(精确搜索)
   */
  private List<String> addressStateInList;

  /**
   * 县(模糊搜索)
   */
  private String addressCounty;

  /**
   * 县 比较(eq)
   */
  private String addressCountyEq;
  /**
   * 县 比较(neq)
   */
  private String addressCountyNeq;
  /**
   * 县 比较(gt)
   */
  private String addressCountyGt;
  /**
   * 县 比较(gte)
   */
  private String addressCountyGte;
  /**
   * 县 比较(lt)
   */
  private String addressCountyLt;
  /**
   * 县 比较(lte)
   */
  private String addressCountyLte;
  /**
   * 县 比较(contains)
   */
  private String addressCountyContains;
  /**
   * 县 比较(notcontains)
   */
  private String addressCountyNotcontains;
  /**
   * 县 比较(startswith)
   */
  private String addressCountyStartswith;
  /**
   * 县 比较(endswith)
   */
  private String addressCountyEndswith;
  /**
   * 县 比较(isnull)
   */
  private Boolean addressCountyIsnull;
  /**
   * 县 比较(isnotnull)
   */
  private Boolean addressCountyIsnotnull;

  /**
   * 县(精确搜索)
   */
  private List<String> addressCountyInList;

  /**
   * 市(模糊搜索)
   */
  private String addressCity;

  /**
   * 市 比较(eq)
   */
  private String addressCityEq;
  /**
   * 市 比较(neq)
   */
  private String addressCityNeq;
  /**
   * 市 比较(gt)
   */
  private String addressCityGt;
  /**
   * 市 比较(gte)
   */
  private String addressCityGte;
  /**
   * 市 比较(lt)
   */
  private String addressCityLt;
  /**
   * 市 比较(lte)
   */
  private String addressCityLte;
  /**
   * 市 比较(contains)
   */
  private String addressCityContains;
  /**
   * 市 比较(notcontains)
   */
  private String addressCityNotcontains;
  /**
   * 市 比较(startswith)
   */
  private String addressCityStartswith;
  /**
   * 市 比较(endswith)
   */
  private String addressCityEndswith;
  /**
   * 市 比较(isnull)
   */
  private Boolean addressCityIsnull;
  /**
   * 市 比较(isnotnull)
   */
  private Boolean addressCityIsnotnull;

  /**
   * 市(精确搜索)
   */
  private List<String> addressCityInList;

  /**
   * 区(模糊搜索)
   */
  private String addressDistrict;

  /**
   * 区 比较(eq)
   */
  private String addressDistrictEq;
  /**
   * 区 比较(neq)
   */
  private String addressDistrictNeq;
  /**
   * 区 比较(gt)
   */
  private String addressDistrictGt;
  /**
   * 区 比较(gte)
   */
  private String addressDistrictGte;
  /**
   * 区 比较(lt)
   */
  private String addressDistrictLt;
  /**
   * 区 比较(lte)
   */
  private String addressDistrictLte;
  /**
   * 区 比较(contains)
   */
  private String addressDistrictContains;
  /**
   * 区 比较(notcontains)
   */
  private String addressDistrictNotcontains;
  /**
   * 区 比较(startswith)
   */
  private String addressDistrictStartswith;
  /**
   * 区 比较(endswith)
   */
  private String addressDistrictEndswith;
  /**
   * 区 比较(isnull)
   */
  private Boolean addressDistrictIsnull;
  /**
   * 区 比较(isnotnull)
   */
  private Boolean addressDistrictIsnotnull;

  /**
   * 区(精确搜索)
   */
  private List<String> addressDistrictInList;

  /**
   * 镇(模糊搜索)
   */
  private String addressTown;

  /**
   * 镇 比较(eq)
   */
  private String addressTownEq;
  /**
   * 镇 比较(neq)
   */
  private String addressTownNeq;
  /**
   * 镇 比较(gt)
   */
  private String addressTownGt;
  /**
   * 镇 比较(gte)
   */
  private String addressTownGte;
  /**
   * 镇 比较(lt)
   */
  private String addressTownLt;
  /**
   * 镇 比较(lte)
   */
  private String addressTownLte;
  /**
   * 镇 比较(contains)
   */
  private String addressTownContains;
  /**
   * 镇 比较(notcontains)
   */
  private String addressTownNotcontains;
  /**
   * 镇 比较(startswith)
   */
  private String addressTownStartswith;
  /**
   * 镇 比较(endswith)
   */
  private String addressTownEndswith;
  /**
   * 镇 比较(isnull)
   */
  private Boolean addressTownIsnull;
  /**
   * 镇 比较(isnotnull)
   */
  private Boolean addressTownIsnotnull;

  /**
   * 镇(精确搜索)
   */
  private List<String> addressTownInList;

  /**
   * 配送地址(模糊搜索)
   */
  private String dropOffLocation;

  /**
   * 配送地址 比较(eq)
   */
  private String dropOffLocationEq;
  /**
   * 配送地址 比较(neq)
   */
  private String dropOffLocationNeq;
  /**
   * 配送地址 比较(gt)
   */
  private String dropOffLocationGt;
  /**
   * 配送地址 比较(gte)
   */
  private String dropOffLocationGte;
  /**
   * 配送地址 比较(lt)
   */
  private String dropOffLocationLt;
  /**
   * 配送地址 比较(lte)
   */
  private String dropOffLocationLte;
  /**
   * 配送地址 比较(contains)
   */
  private String dropOffLocationContains;
  /**
   * 配送地址 比较(notcontains)
   */
  private String dropOffLocationNotcontains;
  /**
   * 配送地址 比较(startswith)
   */
  private String dropOffLocationStartswith;
  /**
   * 配送地址 比较(endswith)
   */
  private String dropOffLocationEndswith;
  /**
   * 配送地址 比较(isnull)
   */
  private Boolean dropOffLocationIsnull;
  /**
   * 配送地址 比较(isnotnull)
   */
  private Boolean dropOffLocationIsnotnull;

  /**
   * 配送地址(精确搜索)
   */
  private List<String> dropOffLocationInList;

  /**
   * 取消原因(模糊搜索)
   */
  private String cancelReason;

  /**
   * 取消原因 比较(eq)
   */
  private String cancelReasonEq;
  /**
   * 取消原因 比较(neq)
   */
  private String cancelReasonNeq;
  /**
   * 取消原因 比较(gt)
   */
  private String cancelReasonGt;
  /**
   * 取消原因 比较(gte)
   */
  private String cancelReasonGte;
  /**
   * 取消原因 比较(lt)
   */
  private String cancelReasonLt;
  /**
   * 取消原因 比较(lte)
   */
  private String cancelReasonLte;
  /**
   * 取消原因 比较(contains)
   */
  private String cancelReasonContains;
  /**
   * 取消原因 比较(notcontains)
   */
  private String cancelReasonNotcontains;
  /**
   * 取消原因 比较(startswith)
   */
  private String cancelReasonStartswith;
  /**
   * 取消原因 比较(endswith)
   */
  private String cancelReasonEndswith;
  /**
   * 取消原因 比较(isnull)
   */
  private Boolean cancelReasonIsnull;
  /**
   * 取消原因 比较(isnotnull)
   */
  private Boolean cancelReasonIsnotnull;

  /**
   * 取消原因(精确搜索)
   */
  private List<String> cancelReasonInList;

  /**
   * 取消请求发起者(模糊搜索)
   */
  private String cancellationInitiator;

  /**
   * 取消请求发起者 比较(eq)
   */
  private String cancellationInitiatorEq;
  /**
   * 取消请求发起者 比较(neq)
   */
  private String cancellationInitiatorNeq;
  /**
   * 取消请求发起者 比较(gt)
   */
  private String cancellationInitiatorGt;
  /**
   * 取消请求发起者 比较(gte)
   */
  private String cancellationInitiatorGte;
  /**
   * 取消请求发起者 比较(lt)
   */
  private String cancellationInitiatorLt;
  /**
   * 取消请求发起者 比较(lte)
   */
  private String cancellationInitiatorLte;
  /**
   * 取消请求发起者 比较(contains)
   */
  private String cancellationInitiatorContains;
  /**
   * 取消请求发起者 比较(notcontains)
   */
  private String cancellationInitiatorNotcontains;
  /**
   * 取消请求发起者 比较(startswith)
   */
  private String cancellationInitiatorStartswith;
  /**
   * 取消请求发起者 比较(endswith)
   */
  private String cancellationInitiatorEndswith;
  /**
   * 取消请求发起者 比较(isnull)
   */
  private Boolean cancellationInitiatorIsnull;
  /**
   * 取消请求发起者 比较(isnotnull)
   */
  private Boolean cancellationInitiatorIsnotnull;

  /**
   * 取消请求发起者(精确搜索)
   */
  private List<String> cancellationInitiatorInList;

  /**
   * 跟踪号(模糊搜索)
   */
  private String trackingNumber;

  /**
   * 跟踪号 比较(eq)
   */
  private String trackingNumberEq;
  /**
   * 跟踪号 比较(neq)
   */
  private String trackingNumberNeq;
  /**
   * 跟踪号 比较(gt)
   */
  private String trackingNumberGt;
  /**
   * 跟踪号 比较(gte)
   */
  private String trackingNumberGte;
  /**
   * 跟踪号 比较(lt)
   */
  private String trackingNumberLt;
  /**
   * 跟踪号 比较(lte)
   */
  private String trackingNumberLte;
  /**
   * 跟踪号 比较(contains)
   */
  private String trackingNumberContains;
  /**
   * 跟踪号 比较(notcontains)
   */
  private String trackingNumberNotcontains;
  /**
   * 跟踪号 比较(startswith)
   */
  private String trackingNumberStartswith;
  /**
   * 跟踪号 比较(endswith)
   */
  private String trackingNumberEndswith;
  /**
   * 跟踪号 比较(isnull)
   */
  private Boolean trackingNumberIsnull;
  /**
   * 跟踪号 比较(isnotnull)
   */
  private Boolean trackingNumberIsnotnull;

  /**
   * 跟踪号(精确搜索)
   */
  private List<String> trackingNumberInList;

  /**
   * 最早卖家发货的时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date rtsTimeStart;

  /**
   * 最晚卖家发货的时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date rtsTimeEnd;

  /**
   * 卖家发货的时间 比较(eq)
   */
  private Date rtsTimeEq;
  /**
   * 卖家发货的时间 比较(neq)
   */
  private Date rtsTimeNeq;
  /**
   * 卖家发货的时间 比较(gt)
   */
  private Date rtsTimeGt;
  /**
   * 卖家发货的时间 比较(gte)
   */
  private Date rtsTimeGte;
  /**
   * 卖家发货的时间 比较(lt)
   */
  private Date rtsTimeLt;
  /**
   * 卖家发货的时间 比较(lte)
   */
  private Date rtsTimeLte;
  /**
   * 卖家发货的时间 比较(contains)
   */
  private Date rtsTimeContains;
  /**
   * 卖家发货的时间 比较(notcontains)
   */
  private Date rtsTimeNotcontains;
  /**
   * 卖家发货的时间 比较(startswith)
   */
  private Date rtsTimeStartswith;
  /**
   * 卖家发货的时间 比较(endswith)
   */
  private Date rtsTimeEndswith;
  /**
   * 卖家发货的时间 比较(isnull)
   */
  private Boolean rtsTimeIsnull;
  /**
   * 卖家发货的时间 比较(isnotnull)
   */
  private Boolean rtsTimeIsnotnull;

  /**
   * 最早平台指定的最晚发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date rtsSlaTimeStart;

  /**
   * 最晚平台指定的最晚发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date rtsSlaTimeEnd;

  /**
   * 平台指定的最晚发货时间 比较(eq)
   */
  private Date rtsSlaTimeEq;
  /**
   * 平台指定的最晚发货时间 比较(neq)
   */
  private Date rtsSlaTimeNeq;
  /**
   * 平台指定的最晚发货时间 比较(gt)
   */
  private Date rtsSlaTimeGt;
  /**
   * 平台指定的最晚发货时间 比较(gte)
   */
  private Date rtsSlaTimeGte;
  /**
   * 平台指定的最晚发货时间 比较(lt)
   */
  private Date rtsSlaTimeLt;
  /**
   * 平台指定的最晚发货时间 比较(lte)
   */
  private Date rtsSlaTimeLte;
  /**
   * 平台指定的最晚发货时间 比较(contains)
   */
  private Date rtsSlaTimeContains;
  /**
   * 平台指定的最晚发货时间 比较(notcontains)
   */
  private Date rtsSlaTimeNotcontains;
  /**
   * 平台指定的最晚发货时间 比较(startswith)
   */
  private Date rtsSlaTimeStartswith;
  /**
   * 平台指定的最晚发货时间 比较(endswith)
   */
  private Date rtsSlaTimeEndswith;
  /**
   * 平台指定的最晚发货时间 比较(isnull)
   */
  private Boolean rtsSlaTimeIsnull;
  /**
   * 平台指定的最晚发货时间 比较(isnotnull)
   */
  private Boolean rtsSlaTimeIsnotnull;

  /**
   * 最早平台指定的最晚揽收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date ttsSlaTimeStart;

  /**
   * 最晚平台指定的最晚揽收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date ttsSlaTimeEnd;

  /**
   * 平台指定的最晚揽收时间 比较(eq)
   */
  private Date ttsSlaTimeEq;
  /**
   * 平台指定的最晚揽收时间 比较(neq)
   */
  private Date ttsSlaTimeNeq;
  /**
   * 平台指定的最晚揽收时间 比较(gt)
   */
  private Date ttsSlaTimeGt;
  /**
   * 平台指定的最晚揽收时间 比较(gte)
   */
  private Date ttsSlaTimeGte;
  /**
   * 平台指定的最晚揽收时间 比较(lt)
   */
  private Date ttsSlaTimeLt;
  /**
   * 平台指定的最晚揽收时间 比较(lte)
   */
  private Date ttsSlaTimeLte;
  /**
   * 平台指定的最晚揽收时间 比较(contains)
   */
  private Date ttsSlaTimeContains;
  /**
   * 平台指定的最晚揽收时间 比较(notcontains)
   */
  private Date ttsSlaTimeNotcontains;
  /**
   * 平台指定的最晚揽收时间 比较(startswith)
   */
  private Date ttsSlaTimeStartswith;
  /**
   * 平台指定的最晚揽收时间 比较(endswith)
   */
  private Date ttsSlaTimeEndswith;
  /**
   * 平台指定的最晚揽收时间 比较(isnull)
   */
  private Boolean ttsSlaTimeIsnull;
  /**
   * 平台指定的最晚揽收时间 比较(isnotnull)
   */
  private Boolean ttsSlaTimeIsnotnull;

  /**
   * 最早订单自动取消时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date cancelOrderSlaTimeStart;

  /**
   * 最晚订单自动取消时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date cancelOrderSlaTimeEnd;

  /**
   * 订单自动取消时间 比较(eq)
   */
  private Date cancelOrderSlaTimeEq;
  /**
   * 订单自动取消时间 比较(neq)
   */
  private Date cancelOrderSlaTimeNeq;
  /**
   * 订单自动取消时间 比较(gt)
   */
  private Date cancelOrderSlaTimeGt;
  /**
   * 订单自动取消时间 比较(gte)
   */
  private Date cancelOrderSlaTimeGte;
  /**
   * 订单自动取消时间 比较(lt)
   */
  private Date cancelOrderSlaTimeLt;
  /**
   * 订单自动取消时间 比较(lte)
   */
  private Date cancelOrderSlaTimeLte;
  /**
   * 订单自动取消时间 比较(contains)
   */
  private Date cancelOrderSlaTimeContains;
  /**
   * 订单自动取消时间 比较(notcontains)
   */
  private Date cancelOrderSlaTimeNotcontains;
  /**
   * 订单自动取消时间 比较(startswith)
   */
  private Date cancelOrderSlaTimeStartswith;
  /**
   * 订单自动取消时间 比较(endswith)
   */
  private Date cancelOrderSlaTimeEndswith;
  /**
   * 订单自动取消时间 比较(isnull)
   */
  private Boolean cancelOrderSlaTimeIsnull;
  /**
   * 订单自动取消时间 比较(isnotnull)
   */
  private Boolean cancelOrderSlaTimeIsnotnull;

  /**
   * 包裹ids(模糊搜索)
   */
  private String packageIds;

  /**
   * 包裹ids 比较(eq)
   */
  private String packageIdsEq;
  /**
   * 包裹ids 比较(neq)
   */
  private String packageIdsNeq;
  /**
   * 包裹ids 比较(gt)
   */
  private String packageIdsGt;
  /**
   * 包裹ids 比较(gte)
   */
  private String packageIdsGte;
  /**
   * 包裹ids 比较(lt)
   */
  private String packageIdsLt;
  /**
   * 包裹ids 比较(lte)
   */
  private String packageIdsLte;
  /**
   * 包裹ids 比较(contains)
   */
  private String packageIdsContains;
  /**
   * 包裹ids 比较(notcontains)
   */
  private String packageIdsNotcontains;
  /**
   * 包裹ids 比较(startswith)
   */
  private String packageIdsStartswith;
  /**
   * 包裹ids 比较(endswith)
   */
  private String packageIdsEndswith;
  /**
   * 包裹ids 比较(isnull)
   */
  private Boolean packageIdsIsnull;
  /**
   * 包裹ids 比较(isnotnull)
   */
  private Boolean packageIdsIsnotnull;

  /**
   * 包裹ids(精确搜索)
   */
  private List<String> packageIdsInList;

  /**
   * 是否更新收件人地址
   */
  private Boolean hasUpdatedRecipientAddress;

  /**
   * 是否更新收件人地址
   */
  private String hasUpdatedRecipientAddressEq;

  /**
   * 买方用户ID(模糊搜索)
   */
  private String userId;

  /**
   * 买方用户ID 比较(eq)
   */
  private String userIdEq;
  /**
   * 买方用户ID 比较(neq)
   */
  private String userIdNeq;
  /**
   * 买方用户ID 比较(gt)
   */
  private String userIdGt;
  /**
   * 买方用户ID 比较(gte)
   */
  private String userIdGte;
  /**
   * 买方用户ID 比较(lt)
   */
  private String userIdLt;
  /**
   * 买方用户ID 比较(lte)
   */
  private String userIdLte;
  /**
   * 买方用户ID 比较(contains)
   */
  private String userIdContains;
  /**
   * 买方用户ID 比较(notcontains)
   */
  private String userIdNotcontains;
  /**
   * 买方用户ID 比较(startswith)
   */
  private String userIdStartswith;
  /**
   * 买方用户ID 比较(endswith)
   */
  private String userIdEndswith;
  /**
   * 买方用户ID 比较(isnull)
   */
  private Boolean userIdIsnull;
  /**
   * 买方用户ID 比较(isnotnull)
   */
  private Boolean userIdIsnotnull;

  /**
   * 买方用户ID(精确搜索)
   */
  private List<String> userIdInList;

  /**
   * 指示订单是合并还是拆分(模糊搜索)
   */
  private String splitOrCombineTag;

  /**
   * 指示订单是合并还是拆分 比较(eq)
   */
  private String splitOrCombineTagEq;
  /**
   * 指示订单是合并还是拆分 比较(neq)
   */
  private String splitOrCombineTagNeq;
  /**
   * 指示订单是合并还是拆分 比较(gt)
   */
  private String splitOrCombineTagGt;
  /**
   * 指示订单是合并还是拆分 比较(gte)
   */
  private String splitOrCombineTagGte;
  /**
   * 指示订单是合并还是拆分 比较(lt)
   */
  private String splitOrCombineTagLt;
  /**
   * 指示订单是合并还是拆分 比较(lte)
   */
  private String splitOrCombineTagLte;
  /**
   * 指示订单是合并还是拆分 比较(contains)
   */
  private String splitOrCombineTagContains;
  /**
   * 指示订单是合并还是拆分 比较(notcontains)
   */
  private String splitOrCombineTagNotcontains;
  /**
   * 指示订单是合并还是拆分 比较(startswith)
   */
  private String splitOrCombineTagStartswith;
  /**
   * 指示订单是合并还是拆分 比较(endswith)
   */
  private String splitOrCombineTagEndswith;
  /**
   * 指示订单是合并还是拆分 比较(isnull)
   */
  private Boolean splitOrCombineTagIsnull;
  /**
   * 指示订单是合并还是拆分 比较(isnotnull)
   */
  private Boolean splitOrCombineTagIsnotnull;

  /**
   * 指示订单是合并还是拆分(精确搜索)
   */
  private List<String> splitOrCombineTagInList;

  /**
   * 发货方式(模糊搜索)
   */
  private String fulfillmentType;

  /**
   * 发货方式 比较(eq)
   */
  private String fulfillmentTypeEq;
  /**
   * 发货方式 比较(neq)
   */
  private String fulfillmentTypeNeq;
  /**
   * 发货方式 比较(gt)
   */
  private String fulfillmentTypeGt;
  /**
   * 发货方式 比较(gte)
   */
  private String fulfillmentTypeGte;
  /**
   * 发货方式 比较(lt)
   */
  private String fulfillmentTypeLt;
  /**
   * 发货方式 比较(lte)
   */
  private String fulfillmentTypeLte;
  /**
   * 发货方式 比较(contains)
   */
  private String fulfillmentTypeContains;
  /**
   * 发货方式 比较(notcontains)
   */
  private String fulfillmentTypeNotcontains;
  /**
   * 发货方式 比较(startswith)
   */
  private String fulfillmentTypeStartswith;
  /**
   * 发货方式 比较(endswith)
   */
  private String fulfillmentTypeEndswith;
  /**
   * 发货方式 比较(isnull)
   */
  private Boolean fulfillmentTypeIsnull;
  /**
   * 发货方式 比较(isnotnull)
   */
  private Boolean fulfillmentTypeIsnotnull;

  /**
   * 发货方式(精确搜索)
   */
  private List<String> fulfillmentTypeInList;

  /**
   * 卖家备注(模糊搜索)
   */
  private String sellerNote;

  /**
   * 卖家备注 比较(eq)
   */
  private String sellerNoteEq;
  /**
   * 卖家备注 比较(neq)
   */
  private String sellerNoteNeq;
  /**
   * 卖家备注 比较(gt)
   */
  private String sellerNoteGt;
  /**
   * 卖家备注 比较(gte)
   */
  private String sellerNoteGte;
  /**
   * 卖家备注 比较(lt)
   */
  private String sellerNoteLt;
  /**
   * 卖家备注 比较(lte)
   */
  private String sellerNoteLte;
  /**
   * 卖家备注 比较(contains)
   */
  private String sellerNoteContains;
  /**
   * 卖家备注 比较(notcontains)
   */
  private String sellerNoteNotcontains;
  /**
   * 卖家备注 比较(startswith)
   */
  private String sellerNoteStartswith;
  /**
   * 卖家备注 比较(endswith)
   */
  private String sellerNoteEndswith;
  /**
   * 卖家备注 比较(isnull)
   */
  private Boolean sellerNoteIsnull;
  /**
   * 卖家备注 比较(isnotnull)
   */
  private Boolean sellerNoteIsnotnull;

  /**
   * 卖家备注(精确搜索)
   */
  private List<String> sellerNoteInList;

  /**
   * 仓库编号(模糊搜索)
   */
  private String warehouseId;

  /**
   * 仓库编号 比较(eq)
   */
  private String warehouseIdEq;
  /**
   * 仓库编号 比较(neq)
   */
  private String warehouseIdNeq;
  /**
   * 仓库编号 比较(gt)
   */
  private String warehouseIdGt;
  /**
   * 仓库编号 比较(gte)
   */
  private String warehouseIdGte;
  /**
   * 仓库编号 比较(lt)
   */
  private String warehouseIdLt;
  /**
   * 仓库编号 比较(lte)
   */
  private String warehouseIdLte;
  /**
   * 仓库编号 比较(contains)
   */
  private String warehouseIdContains;
  /**
   * 仓库编号 比较(notcontains)
   */
  private String warehouseIdNotcontains;
  /**
   * 仓库编号 比较(startswith)
   */
  private String warehouseIdStartswith;
  /**
   * 仓库编号 比较(endswith)
   */
  private String warehouseIdEndswith;
  /**
   * 仓库编号 比较(isnull)
   */
  private Boolean warehouseIdIsnull;
  /**
   * 仓库编号 比较(isnotnull)
   */
  private Boolean warehouseIdIsnotnull;

  /**
   * 仓库编号(精确搜索)
   */
  private List<String> warehouseIdInList;

  /**
   * 付款方式名称(模糊搜索)
   */
  private String paymentMethodName;

  /**
   * 付款方式名称 比较(eq)
   */
  private String paymentMethodNameEq;
  /**
   * 付款方式名称 比较(neq)
   */
  private String paymentMethodNameNeq;
  /**
   * 付款方式名称 比较(gt)
   */
  private String paymentMethodNameGt;
  /**
   * 付款方式名称 比较(gte)
   */
  private String paymentMethodNameGte;
  /**
   * 付款方式名称 比较(lt)
   */
  private String paymentMethodNameLt;
  /**
   * 付款方式名称 比较(lte)
   */
  private String paymentMethodNameLte;
  /**
   * 付款方式名称 比较(contains)
   */
  private String paymentMethodNameContains;
  /**
   * 付款方式名称 比较(notcontains)
   */
  private String paymentMethodNameNotcontains;
  /**
   * 付款方式名称 比较(startswith)
   */
  private String paymentMethodNameStartswith;
  /**
   * 付款方式名称 比较(endswith)
   */
  private String paymentMethodNameEndswith;
  /**
   * 付款方式名称 比较(isnull)
   */
  private Boolean paymentMethodNameIsnull;
  /**
   * 付款方式名称 比较(isnotnull)
   */
  private Boolean paymentMethodNameIsnotnull;

  /**
   * 付款方式名称(精确搜索)
   */
  private List<String> paymentMethodNameInList;

  /**
   * 配送方式(模糊搜索)
   */
  private String shippingType;

  /**
   * 配送方式 比较(eq)
   */
  private String shippingTypeEq;
  /**
   * 配送方式 比较(neq)
   */
  private String shippingTypeNeq;
  /**
   * 配送方式 比较(gt)
   */
  private String shippingTypeGt;
  /**
   * 配送方式 比较(gte)
   */
  private String shippingTypeGte;
  /**
   * 配送方式 比较(lt)
   */
  private String shippingTypeLt;
  /**
   * 配送方式 比较(lte)
   */
  private String shippingTypeLte;
  /**
   * 配送方式 比较(contains)
   */
  private String shippingTypeContains;
  /**
   * 配送方式 比较(notcontains)
   */
  private String shippingTypeNotcontains;
  /**
   * 配送方式 比较(startswith)
   */
  private String shippingTypeStartswith;
  /**
   * 配送方式 比较(endswith)
   */
  private String shippingTypeEndswith;
  /**
   * 配送方式 比较(isnull)
   */
  private Boolean shippingTypeIsnull;
  /**
   * 配送方式 比较(isnotnull)
   */
  private Boolean shippingTypeIsnotnull;

  /**
   * 配送方式(精确搜索)
   */
  private List<String> shippingTypeInList;

  /**
   * 物流方式名称(模糊搜索)
   */
  private String deliveryOptionName;

  /**
   * 物流方式名称 比较(eq)
   */
  private String deliveryOptionNameEq;
  /**
   * 物流方式名称 比较(neq)
   */
  private String deliveryOptionNameNeq;
  /**
   * 物流方式名称 比较(gt)
   */
  private String deliveryOptionNameGt;
  /**
   * 物流方式名称 比较(gte)
   */
  private String deliveryOptionNameGte;
  /**
   * 物流方式名称 比较(lt)
   */
  private String deliveryOptionNameLt;
  /**
   * 物流方式名称 比较(lte)
   */
  private String deliveryOptionNameLte;
  /**
   * 物流方式名称 比较(contains)
   */
  private String deliveryOptionNameContains;
  /**
   * 物流方式名称 比较(notcontains)
   */
  private String deliveryOptionNameNotcontains;
  /**
   * 物流方式名称 比较(startswith)
   */
  private String deliveryOptionNameStartswith;
  /**
   * 物流方式名称 比较(endswith)
   */
  private String deliveryOptionNameEndswith;
  /**
   * 物流方式名称 比较(isnull)
   */
  private Boolean deliveryOptionNameIsnull;
  /**
   * 物流方式名称 比较(isnotnull)
   */
  private Boolean deliveryOptionNameIsnotnull;

  /**
   * 物流方式名称(精确搜索)
   */
  private List<String> deliveryOptionNameInList;

  /**
   * 物流方式ID(模糊搜索)
   */
  private String deliveryOptionId;

  /**
   * 物流方式ID 比较(eq)
   */
  private String deliveryOptionIdEq;
  /**
   * 物流方式ID 比较(neq)
   */
  private String deliveryOptionIdNeq;
  /**
   * 物流方式ID 比较(gt)
   */
  private String deliveryOptionIdGt;
  /**
   * 物流方式ID 比较(gte)
   */
  private String deliveryOptionIdGte;
  /**
   * 物流方式ID 比较(lt)
   */
  private String deliveryOptionIdLt;
  /**
   * 物流方式ID 比较(lte)
   */
  private String deliveryOptionIdLte;
  /**
   * 物流方式ID 比较(contains)
   */
  private String deliveryOptionIdContains;
  /**
   * 物流方式ID 比较(notcontains)
   */
  private String deliveryOptionIdNotcontains;
  /**
   * 物流方式ID 比较(startswith)
   */
  private String deliveryOptionIdStartswith;
  /**
   * 物流方式ID 比较(endswith)
   */
  private String deliveryOptionIdEndswith;
  /**
   * 物流方式ID 比较(isnull)
   */
  private Boolean deliveryOptionIdIsnull;
  /**
   * 物流方式ID 比较(isnotnull)
   */
  private Boolean deliveryOptionIdIsnotnull;

  /**
   * 物流方式ID(精确搜索)
   */
  private List<String> deliveryOptionIdInList;

  /**
   * 最早最晚交货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliverySlaTimeStart;

  /**
   * 最晚最晚交货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliverySlaTimeEnd;

  /**
   * 最晚交货时间 比较(eq)
   */
  private Date deliverySlaTimeEq;
  /**
   * 最晚交货时间 比较(neq)
   */
  private Date deliverySlaTimeNeq;
  /**
   * 最晚交货时间 比较(gt)
   */
  private Date deliverySlaTimeGt;
  /**
   * 最晚交货时间 比较(gte)
   */
  private Date deliverySlaTimeGte;
  /**
   * 最晚交货时间 比较(lt)
   */
  private Date deliverySlaTimeLt;
  /**
   * 最晚交货时间 比较(lte)
   */
  private Date deliverySlaTimeLte;
  /**
   * 最晚交货时间 比较(contains)
   */
  private Date deliverySlaTimeContains;
  /**
   * 最晚交货时间 比较(notcontains)
   */
  private Date deliverySlaTimeNotcontains;
  /**
   * 最晚交货时间 比较(startswith)
   */
  private Date deliverySlaTimeStartswith;
  /**
   * 最晚交货时间 比较(endswith)
   */
  private Date deliverySlaTimeEndswith;
  /**
   * 最晚交货时间 比较(isnull)
   */
  private Boolean deliverySlaTimeIsnull;
  /**
   * 最晚交货时间 比较(isnotnull)
   */
  private Boolean deliverySlaTimeIsnotnull;

  /**
   * 是否货到付款
   */
  private Boolean isCod;

  /**
   * 是否货到付款
   */
  private String isCodEq;

  /**
   * 是否为示例订单
   */
  private Boolean isSampleOrder;

  /**
   * 是否为示例订单
   */
  private String isSampleOrderEq;

  /**
   * 需要上传发票(模糊搜索)
   */
  private String needUploadInvoice;

  /**
   * 需要上传发票 比较(eq)
   */
  private String needUploadInvoiceEq;
  /**
   * 需要上传发票 比较(neq)
   */
  private String needUploadInvoiceNeq;
  /**
   * 需要上传发票 比较(gt)
   */
  private String needUploadInvoiceGt;
  /**
   * 需要上传发票 比较(gte)
   */
  private String needUploadInvoiceGte;
  /**
   * 需要上传发票 比较(lt)
   */
  private String needUploadInvoiceLt;
  /**
   * 需要上传发票 比较(lte)
   */
  private String needUploadInvoiceLte;
  /**
   * 需要上传发票 比较(contains)
   */
  private String needUploadInvoiceContains;
  /**
   * 需要上传发票 比较(notcontains)
   */
  private String needUploadInvoiceNotcontains;
  /**
   * 需要上传发票 比较(startswith)
   */
  private String needUploadInvoiceStartswith;
  /**
   * 需要上传发票 比较(endswith)
   */
  private String needUploadInvoiceEndswith;
  /**
   * 需要上传发票 比较(isnull)
   */
  private Boolean needUploadInvoiceIsnull;
  /**
   * 需要上传发票 比较(isnotnull)
   */
  private Boolean needUploadInvoiceIsnotnull;

  /**
   * 需要上传发票(精确搜索)
   */
  private List<String> needUploadInvoiceInList;

  /**
   * 买家电子邮件地址(模糊搜索)
   */
  private String buyerEmail;

  /**
   * 买家电子邮件地址 比较(eq)
   */
  private String buyerEmailEq;
  /**
   * 买家电子邮件地址 比较(neq)
   */
  private String buyerEmailNeq;
  /**
   * 买家电子邮件地址 比较(gt)
   */
  private String buyerEmailGt;
  /**
   * 买家电子邮件地址 比较(gte)
   */
  private String buyerEmailGte;
  /**
   * 买家电子邮件地址 比较(lt)
   */
  private String buyerEmailLt;
  /**
   * 买家电子邮件地址 比较(lte)
   */
  private String buyerEmailLte;
  /**
   * 买家电子邮件地址 比较(contains)
   */
  private String buyerEmailContains;
  /**
   * 买家电子邮件地址 比较(notcontains)
   */
  private String buyerEmailNotcontains;
  /**
   * 买家电子邮件地址 比较(startswith)
   */
  private String buyerEmailStartswith;
  /**
   * 买家电子邮件地址 比较(endswith)
   */
  private String buyerEmailEndswith;
  /**
   * 买家电子邮件地址 比较(isnull)
   */
  private Boolean buyerEmailIsnull;
  /**
   * 买家电子邮件地址 比较(isnotnull)
   */
  private Boolean buyerEmailIsnotnull;

  /**
   * 买家电子邮件地址(精确搜索)
   */
  private List<String> buyerEmailInList;

  /**
   * 发票号码(模糊搜索)
   */
  private String cpf;

  /**
   * 发票号码 比较(eq)
   */
  private String cpfEq;
  /**
   * 发票号码 比较(neq)
   */
  private String cpfNeq;
  /**
   * 发票号码 比较(gt)
   */
  private String cpfGt;
  /**
   * 发票号码 比较(gte)
   */
  private String cpfGte;
  /**
   * 发票号码 比较(lt)
   */
  private String cpfLt;
  /**
   * 发票号码 比较(lte)
   */
  private String cpfLte;
  /**
   * 发票号码 比较(contains)
   */
  private String cpfContains;
  /**
   * 发票号码 比较(notcontains)
   */
  private String cpfNotcontains;
  /**
   * 发票号码 比较(startswith)
   */
  private String cpfStartswith;
  /**
   * 发票号码 比较(endswith)
   */
  private String cpfEndswith;
  /**
   * 发票号码 比较(isnull)
   */
  private Boolean cpfIsnull;
  /**
   * 发票号码 比较(isnotnull)
   */
  private Boolean cpfIsnotnull;

  /**
   * 发票号码(精确搜索)
   */
  private List<String> cpfInList;

  /**
   * 是否暂定订单
   */
  private Boolean isOnHoldOrder;

  /**
   * 是否暂定订单
   */
  private String isOnHoldOrderEq;

  /**
   * 是否待处理取消订单
   */
  private Boolean isBuyerRequestCancel;

  /**
   * 是否待处理取消订单
   */
  private String isBuyerRequestCancelEq;

  /**
   * 最早买方发起取消时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date requestCancelTimeStart;

  /**
   * 最晚买方发起取消时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date requestCancelTimeEnd;

  /**
   * 买方发起取消时间 比较(eq)
   */
  private Date requestCancelTimeEq;
  /**
   * 买方发起取消时间 比较(neq)
   */
  private Date requestCancelTimeNeq;
  /**
   * 买方发起取消时间 比较(gt)
   */
  private Date requestCancelTimeGt;
  /**
   * 买方发起取消时间 比较(gte)
   */
  private Date requestCancelTimeGte;
  /**
   * 买方发起取消时间 比较(lt)
   */
  private Date requestCancelTimeLt;
  /**
   * 买方发起取消时间 比较(lte)
   */
  private Date requestCancelTimeLte;
  /**
   * 买方发起取消时间 比较(contains)
   */
  private Date requestCancelTimeContains;
  /**
   * 买方发起取消时间 比较(notcontains)
   */
  private Date requestCancelTimeNotcontains;
  /**
   * 买方发起取消时间 比较(startswith)
   */
  private Date requestCancelTimeStartswith;
  /**
   * 买方发起取消时间 比较(endswith)
   */
  private Date requestCancelTimeEndswith;
  /**
   * 买方发起取消时间 比较(isnull)
   */
  private Boolean requestCancelTimeIsnull;
  /**
   * 买方发起取消时间 比较(isnotnull)
   */
  private Boolean requestCancelTimeIsnotnull;

  /**
   * 最早最晚发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveryOptionRequiredDeliveryTimeStart;

  /**
   * 最晚最晚发货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveryOptionRequiredDeliveryTimeEnd;

  /**
   * 最晚发货时间 比较(eq)
   */
  private Date deliveryOptionRequiredDeliveryTimeEq;
  /**
   * 最晚发货时间 比较(neq)
   */
  private Date deliveryOptionRequiredDeliveryTimeNeq;
  /**
   * 最晚发货时间 比较(gt)
   */
  private Date deliveryOptionRequiredDeliveryTimeGt;
  /**
   * 最晚发货时间 比较(gte)
   */
  private Date deliveryOptionRequiredDeliveryTimeGte;
  /**
   * 最晚发货时间 比较(lt)
   */
  private Date deliveryOptionRequiredDeliveryTimeLt;
  /**
   * 最晚发货时间 比较(lte)
   */
  private Date deliveryOptionRequiredDeliveryTimeLte;
  /**
   * 最晚发货时间 比较(contains)
   */
  private Date deliveryOptionRequiredDeliveryTimeContains;
  /**
   * 最晚发货时间 比较(notcontains)
   */
  private Date deliveryOptionRequiredDeliveryTimeNotcontains;
  /**
   * 最晚发货时间 比较(startswith)
   */
  private Date deliveryOptionRequiredDeliveryTimeStartswith;
  /**
   * 最晚发货时间 比较(endswith)
   */
  private Date deliveryOptionRequiredDeliveryTimeEndswith;
  /**
   * 最晚发货时间 比较(isnull)
   */
  private Boolean deliveryOptionRequiredDeliveryTimeIsnull;
  /**
   * 最晚发货时间 比较(isnotnull)
   */
  private Boolean deliveryOptionRequiredDeliveryTimeIsnotnull;

  /**
   * 最早最晚揽收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date shippingDueTimeStart;

  /**
   * 最晚最晚揽收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date shippingDueTimeEnd;

  /**
   * 最晚揽收时间 比较(eq)
   */
  private Date shippingDueTimeEq;
  /**
   * 最晚揽收时间 比较(neq)
   */
  private Date shippingDueTimeNeq;
  /**
   * 最晚揽收时间 比较(gt)
   */
  private Date shippingDueTimeGt;
  /**
   * 最晚揽收时间 比较(gte)
   */
  private Date shippingDueTimeGte;
  /**
   * 最晚揽收时间 比较(lt)
   */
  private Date shippingDueTimeLt;
  /**
   * 最晚揽收时间 比较(lte)
   */
  private Date shippingDueTimeLte;
  /**
   * 最晚揽收时间 比较(contains)
   */
  private Date shippingDueTimeContains;
  /**
   * 最晚揽收时间 比较(notcontains)
   */
  private Date shippingDueTimeNotcontains;
  /**
   * 最晚揽收时间 比较(startswith)
   */
  private Date shippingDueTimeStartswith;
  /**
   * 最晚揽收时间 比较(endswith)
   */
  private Date shippingDueTimeEndswith;
  /**
   * 最晚揽收时间 比较(isnull)
   */
  private Boolean shippingDueTimeIsnull;
  /**
   * 最晚揽收时间 比较(isnotnull)
   */
  private Boolean shippingDueTimeIsnotnull;

  /**
   * 最早最晚运送时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date collectionDueTimeStart;

  /**
   * 最晚最晚运送时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date collectionDueTimeEnd;

  /**
   * 最晚运送时间 比较(eq)
   */
  private Date collectionDueTimeEq;
  /**
   * 最晚运送时间 比较(neq)
   */
  private Date collectionDueTimeNeq;
  /**
   * 最晚运送时间 比较(gt)
   */
  private Date collectionDueTimeGt;
  /**
   * 最晚运送时间 比较(gte)
   */
  private Date collectionDueTimeGte;
  /**
   * 最晚运送时间 比较(lt)
   */
  private Date collectionDueTimeLt;
  /**
   * 最晚运送时间 比较(lte)
   */
  private Date collectionDueTimeLte;
  /**
   * 最晚运送时间 比较(contains)
   */
  private Date collectionDueTimeContains;
  /**
   * 最晚运送时间 比较(notcontains)
   */
  private Date collectionDueTimeNotcontains;
  /**
   * 最晚运送时间 比较(startswith)
   */
  private Date collectionDueTimeStartswith;
  /**
   * 最晚运送时间 比较(endswith)
   */
  private Date collectionDueTimeEndswith;
  /**
   * 最晚运送时间 比较(isnull)
   */
  private Boolean collectionDueTimeIsnull;
  /**
   * 最晚运送时间 比较(isnotnull)
   */
  private Boolean collectionDueTimeIsnotnull;

  /**
   * 最早最晚送达时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveryDueTimeStart;

  /**
   * 最晚最晚送达时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveryDueTimeEnd;

  /**
   * 最晚送达时间 比较(eq)
   */
  private Date deliveryDueTimeEq;
  /**
   * 最晚送达时间 比较(neq)
   */
  private Date deliveryDueTimeNeq;
  /**
   * 最晚送达时间 比较(gt)
   */
  private Date deliveryDueTimeGt;
  /**
   * 最晚送达时间 比较(gte)
   */
  private Date deliveryDueTimeGte;
  /**
   * 最晚送达时间 比较(lt)
   */
  private Date deliveryDueTimeLt;
  /**
   * 最晚送达时间 比较(lte)
   */
  private Date deliveryDueTimeLte;
  /**
   * 最晚送达时间 比较(contains)
   */
  private Date deliveryDueTimeContains;
  /**
   * 最晚送达时间 比较(notcontains)
   */
  private Date deliveryDueTimeNotcontains;
  /**
   * 最晚送达时间 比较(startswith)
   */
  private Date deliveryDueTimeStartswith;
  /**
   * 最晚送达时间 比较(endswith)
   */
  private Date deliveryDueTimeEndswith;
  /**
   * 最晚送达时间 比较(isnull)
   */
  private Boolean deliveryDueTimeIsnull;
  /**
   * 最晚送达时间 比较(isnotnull)
   */
  private Boolean deliveryDueTimeIsnotnull;

  /**
   * 最早揽收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date collectionTimeStart;

  /**
   * 最晚揽收时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date collectionTimeEnd;

  /**
   * 揽收时间 比较(eq)
   */
  private Date collectionTimeEq;
  /**
   * 揽收时间 比较(neq)
   */
  private Date collectionTimeNeq;
  /**
   * 揽收时间 比较(gt)
   */
  private Date collectionTimeGt;
  /**
   * 揽收时间 比较(gte)
   */
  private Date collectionTimeGte;
  /**
   * 揽收时间 比较(lt)
   */
  private Date collectionTimeLt;
  /**
   * 揽收时间 比较(lte)
   */
  private Date collectionTimeLte;
  /**
   * 揽收时间 比较(contains)
   */
  private Date collectionTimeContains;
  /**
   * 揽收时间 比较(notcontains)
   */
  private Date collectionTimeNotcontains;
  /**
   * 揽收时间 比较(startswith)
   */
  private Date collectionTimeStartswith;
  /**
   * 揽收时间 比较(endswith)
   */
  private Date collectionTimeEndswith;
  /**
   * 揽收时间 比较(isnull)
   */
  private Boolean collectionTimeIsnull;
  /**
   * 揽收时间 比较(isnotnull)
   */
  private Boolean collectionTimeIsnotnull;

  /**
   * 最早派送时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveryTimeStart;

  /**
   * 最晚派送时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date deliveryTimeEnd;

  /**
   * 派送时间 比较(eq)
   */
  private Date deliveryTimeEq;
  /**
   * 派送时间 比较(neq)
   */
  private Date deliveryTimeNeq;
  /**
   * 派送时间 比较(gt)
   */
  private Date deliveryTimeGt;
  /**
   * 派送时间 比较(gte)
   */
  private Date deliveryTimeGte;
  /**
   * 派送时间 比较(lt)
   */
  private Date deliveryTimeLt;
  /**
   * 派送时间 比较(lte)
   */
  private Date deliveryTimeLte;
  /**
   * 派送时间 比较(contains)
   */
  private Date deliveryTimeContains;
  /**
   * 派送时间 比较(notcontains)
   */
  private Date deliveryTimeNotcontains;
  /**
   * 派送时间 比较(startswith)
   */
  private Date deliveryTimeStartswith;
  /**
   * 派送时间 比较(endswith)
   */
  private Date deliveryTimeEndswith;
  /**
   * 派送时间 比较(isnull)
   */
  private Boolean deliveryTimeIsnull;
  /**
   * 派送时间 比较(isnotnull)
   */
  private Boolean deliveryTimeIsnotnull;

  /**
   * 最早取消时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date cancelTimeStart;

  /**
   * 最晚取消时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date cancelTimeEnd;

  /**
   * 取消时间 比较(eq)
   */
  private Date cancelTimeEq;
  /**
   * 取消时间 比较(neq)
   */
  private Date cancelTimeNeq;
  /**
   * 取消时间 比较(gt)
   */
  private Date cancelTimeGt;
  /**
   * 取消时间 比较(gte)
   */
  private Date cancelTimeGte;
  /**
   * 取消时间 比较(lt)
   */
  private Date cancelTimeLt;
  /**
   * 取消时间 比较(lte)
   */
  private Date cancelTimeLte;
  /**
   * 取消时间 比较(contains)
   */
  private Date cancelTimeContains;
  /**
   * 取消时间 比较(notcontains)
   */
  private Date cancelTimeNotcontains;
  /**
   * 取消时间 比较(startswith)
   */
  private Date cancelTimeStartswith;
  /**
   * 取消时间 比较(endswith)
   */
  private Date cancelTimeEndswith;
  /**
   * 取消时间 比较(isnull)
   */
  private Boolean cancelTimeIsnull;
  /**
   * 取消时间 比较(isnotnull)
   */
  private Boolean cancelTimeIsnotnull;

  /**
   * 店铺id
   */
  private Long sid;

  /**
   * 最小店铺id
   */
  private Long sidMin;

  /**
   * 最大店铺id
   */
  private Long sidMax;

  /**
   * 店铺id 比较(eq)
   */
  private Long sidEq;
  /**
   * 店铺id 比较(neq)
   */
  private Long sidNeq;
  /**
   * 店铺id 比较(gt)
   */
  private Long sidGt;
  /**
   * 店铺id 比较(gte)
   */
  private Long sidGte;
  /**
   * 店铺id 比较(lt)
   */
  private Long sidLt;
  /**
   * 店铺id 比较(lte)
   */
  private Long sidLte;
  /**
   * 店铺id 比较(contains)
   */
  private Long sidContains;
  /**
   * 店铺id 比较(notcontains)
   */
  private Long sidNotcontains;
  /**
   * 店铺id 比较(startswith)
   */
  private Long sidStartswith;
  /**
   * 店铺id 比较(endswith)
   */
  private Long sidEndswith;
  /**
   * 店铺id 比较(isnull)
   */
  private Boolean sidIsnull;
  /**
   * 店铺id 比较(isnotnull)
   */
  private Boolean sidIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
